package io.vavr.collection;
   
   import io.vavr.Value;
   import org.assertj.core.api.Assertions;
   import org.junit.Test;
   
   import java.math.BigDecimal;
   import java.util.ArrayList;
   import java.util.Spliterator;
  import java.util.function.Function;
  import java.util.function.Supplier;
  import java.util.stream.Collector;
  
  public class LinkedHashSetTest extends AbstractSetTest {
  
      @Override
      protected <T> Collector<T, ArrayList<T>, LinkedHashSet<T>> collector() {
          return LinkedHashSet.collector();
      }
  
      @Override
      protected <T> LinkedHashSet<T> empty() {
          return LinkedHashSet.empty();
      }
  
      @Override
      protected <T> LinkedHashSet<T> emptyWithNull() {
          return empty();
      }
  
      @Override
      protected <T> LinkedHashSet<T> of(T element) {
          return LinkedHashSet.of(element);
      }
  
      @SuppressWarnings("varargs")
      @SafeVarargs
      @Override
      protected final <T> LinkedHashSet<T> of(T... elements) {
          return LinkedHashSet.of(elements);
      }
  
      @Override
      protected boolean useIsEqualToInsteadOfIsSameAs() {
          return false;
      }
  
      @Override
      protected int getPeekNonNilPerformingAnAction() {
          return 1;
      }
  
      @Override
      protected <T> LinkedHashSet<T> ofAll(Iterable<? extends T> elements) {
          return LinkedHashSet.ofAll(elements);
      }
  
      @Override
      protected <T extends Comparable<? super T>> LinkedHashSet<T> ofJavaStream(java.util.stream.Stream<? extends T> javaStream) {
          return LinkedHashSet.ofAll(javaStream);
      }
  
      @Override
      protected LinkedHashSet<Boolean> ofAll(boolean... elements) {
          return LinkedHashSet.ofAll(elements);
      }
  
      @Override
      protected LinkedHashSet<Byte> ofAll(byte... elements) {
          return LinkedHashSet.ofAll(elements);
      }
  
      @Override
      protected LinkedHashSet<Character> ofAll(char... elements) {
          return LinkedHashSet.ofAll(elements);
      }
  
      @Override
      protected LinkedHashSet<Double> ofAll(double... elements) {
          return LinkedHashSet.ofAll(elements);
      }
  
      @Override
      protected LinkedHashSet<Float> ofAll(float... elements) {
          return LinkedHashSet.ofAll(elements);
      }
  
      @Override
      protected LinkedHashSet<Integer> ofAll(int... elements) {
          return LinkedHashSet.ofAll(elements);
      }
  
      @Override
      protected LinkedHashSet<Long> ofAll(long... elements) {
          return LinkedHashSet.ofAll(elements);
      }
  
      @Override
      protected LinkedHashSet<Short> ofAll(short... elements) {
         return LinkedHashSet.ofAll(elements);
     }
 
     @Override
     protected <T> LinkedHashSet<T> tabulate(int n, Function<? super Integer, ? extends T> f) {
         return LinkedHashSet.tabulate(n, f);
     }
 
     @Override
     protected <T> LinkedHashSet<T> fill(int n, Supplier<? extends T> s) {
         return LinkedHashSet.fill(n, s);
     }
 
     @Override
     protected LinkedHashSet<Character> range(char from, char toExclusive) {
         return LinkedHashSet.range(from, toExclusive);
     }
 
     @Override
     protected LinkedHashSet<Character> rangeBy(char from, char toExclusive, int step) {
         return LinkedHashSet.rangeBy(from, toExclusive, step);
     }
 
     @Override
     protected LinkedHashSet<Double> rangeBy(double from, double toExclusive, double step) {
         return LinkedHashSet.rangeBy(from, toExclusive, step);
     }
 
     @Override
     protected LinkedHashSet<Integer> range(int from, int toExclusive) {
         return LinkedHashSet.range(from, toExclusive);
     }
 
     @Override
     protected LinkedHashSet<Integer> rangeBy(int from, int toExclusive, int step) {
         return LinkedHashSet.rangeBy(from, toExclusive, step);
     }
 
     @Override
     protected LinkedHashSet<Long> range(long from, long toExclusive) {
         return LinkedHashSet.range(from, toExclusive);
     }
 
     @Override
     protected LinkedHashSet<Long> rangeBy(long from, long toExclusive, long step) {
         return LinkedHashSet.rangeBy(from, toExclusive, step);
     }
 
     @Override
     protected LinkedHashSet<Character> rangeClosed(char from, char toInclusive) {
         return LinkedHashSet.rangeClosed(from, toInclusive);
     }
 
     @Override
     protected LinkedHashSet<Character> rangeClosedBy(char from, char toInclusive, int step) {
         return LinkedHashSet.rangeClosedBy(from, toInclusive, step);
     }
 
     @Override
     protected LinkedHashSet<Double> rangeClosedBy(double from, double toInclusive, double step) {
         return LinkedHashSet.rangeClosedBy(from, toInclusive, step);
     }
 
     @Override
     protected LinkedHashSet<Integer> rangeClosed(int from, int toInclusive) {
         return LinkedHashSet.rangeClosed(from, toInclusive);
     }
 
     @Override
     protected LinkedHashSet<Integer> rangeClosedBy(int from, int toInclusive, int step) {
         return LinkedHashSet.rangeClosedBy(from, toInclusive, step);
     }
 
     @Override
     protected LinkedHashSet<Long> rangeClosed(long from, long toInclusive) {
         return LinkedHashSet.rangeClosed(from, toInclusive);
     }
 
     @Override
     protected LinkedHashSet<Long> rangeClosedBy(long from, long toInclusive, long step) {
         return LinkedHashSet.rangeClosedBy(from, toInclusive, step);
     }
 
     @Test
     public void shouldKeepOrder() {
         final List<Integer> actual = LinkedHashSet.<Integer> empty().add(3).add(2).add(1).toList();
         assertThat(actual).isEqualTo(List.of(3, 2, 1));
     }
 
     // -- static narrow
 
     @Test
     public void shouldNarrowLinkedHashSet() {
         final LinkedHashSet<Double> doubles = of(1.0d);
         final LinkedHashSet<Number> numbers = LinkedHashSet.narrow(doubles);
         final int actual = numbers.add(new BigDecimal("2.0")).sum().intValue();
         assertThat(actual).isEqualTo(3);
     }
 
     // -- replace
 
     @Test
     public void shouldReturnSameInstanceIfReplacingNonExistingElement() {
         final Set<Integer> set = LinkedHashSet.of(1, 2, 3);
         final Set<Integer> actual = set.replace(4, 0);
         assertThat(actual).isSameAs(set);
     }
 
     @Test
     public void shouldPreserveOrderWhenReplacingExistingElement() {
         final Set<Integer> set = LinkedHashSet.of(1, 2, 3);
         final Set<Integer> actual = set.replace(2, 0);
         final Set<Integer> expected = LinkedHashSet.of(1, 0, 3);
         assertThat(actual).isEqualTo(expected);
         Assertions.assertThat(List.ofAll(actual)).isEqualTo(List.ofAll(expected));
     }
 
     @Test
     public void shouldPreserveOrderWhenReplacingExistingElementAndRemoveOtherIfElementAlreadyExists() {
         final Set<Integer> set = LinkedHashSet.of(1, 2, 3, 4, 5);
         final Set<Integer> actual = set.replace(2, 4);
         final Set<Integer> expected = LinkedHashSet.of(1, 4, 3, 5);
         assertThat(actual).isEqualTo(expected);
         Assertions.assertThat(List.ofAll(actual)).isEqualTo(List.ofAll(expected));
     }
 
     @Test
     public void shouldReturnSameInstanceWhenReplacingExistingElementWithIdentity() {
         final Set<Integer> set = LinkedHashSet.of(1, 2, 3);
         final Set<Integer> actual = set.replace(2, 2);
         assertThat(actual).isSameAs(set);
     }
 
     // -- transform
 
     @Test
     public void shouldTransform() {
         final String transformed = of(42).transform(v -> String.valueOf(v.get()));
         assertThat(transformed).isEqualTo("42");
     }
 
     // -- toLinkedSet
 
     @Test
     public void shouldReturnSelfOnConvertToLinkedSet() {
         final Value<Integer> value = of(1, 2, 3);
         assertThat(value.toLinkedSet()).isSameAs(value);
     }
 
     // -- spliterator
 
     @Test
     public void shouldNotHaveSortedSpliterator() {
         assertThat(of(1, 2, 3).spliterator().hasCharacteristics(Spliterator.SORTED)).isFalse();
     }
 
     @Test
     public void shouldHaveOrderedSpliterator() {
         assertThat(of(1, 2, 3).spliterator().hasCharacteristics(Spliterator.ORDERED)).isTrue();
     }
 
     // -- isSequential()
 
     @Test
     public void shouldReturnTrueWhenIsSequentialCalled() {
         assertThat(of(1, 2, 3).isSequential()).isTrue();
     }
 
 }